In [1]:
# Used to display all the matplotlib graphs inside the notebook
%matplotlib inline
# Hiding the warnings
import warnings
warnings.filterwarnings('ignore')
Importing all the necessary libraries¶
In [2]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
In [3]:
sns.set() # Setting the default seaborn style for all the plots
In [4]:
data = pd.read_csv('vehicle-1.csv') # Storing the given data into a data frame called as "data"
Exploratory Data Analysis¶
Number of records, structure of the file, number of attributes¶
In [5]:
data.shape # The data has got 195 rows and 24 columns
Out[5]:
In [6]:
data.head() # Checking the head of the data frame
Out[6]:
In [7]:
# Checking for duplicates and removing the duplicates
print('The shape before removing the duplicates from the data set is :',data.shape)
data = data.drop_duplicates()
print('The shape after removing the duplicates from the data set is :',data.shape)
In [8]:
data.info() # Checking for the data type of each of the variables and the number of non-null values
In [9]:
data.nunique() # To check for the presence of categorical variables
Out[9]:
Checking for null values in each of the columns¶
In [10]:
data.isnull().sum()
Out[10]:
In [11]:
# Replacing the null values in each of the columns using linear interpolation
columns = list(data.columns)
for column in columns:
if data[column].count() != data.shape[0]:
data[column] = data[column].interpolate(method="linear")
In [12]:
data.isnull().sum()
Out[12]:
-There are no null values present in the data set¶
In [13]:
sns.pairplot(data)
Out[13]:
The five point summary of the continuous variables¶
In [14]:
data.describe().T
Out[14]:
In [15]:
corr = data.corr() # Finding the correlation between the variables
In [16]:
fig, ax = plt.subplots(figsize=(20,20))
sns.heatmap(corr, annot=True,ax=ax,cmap='Pastel2')
Out[16]:
Observing the distribution of the target variable¶
In [17]:
sns.countplot(data['class'],edgecolor = 'black', alpha = 0.7)
Out[17]:
Looks like the 'class' is normally distributed with not much of skewness¶
In [18]:
# Getting the count of the distribution of records in each of the three classes namely van,car and bus
grouped_data = data.groupby('class').size()
print(grouped_data)
Distributions of the predictors (continuous)¶
In [19]:
X = data.drop('class',axis=1)
c_cols = X.columns.to_list()
for column in c_cols :
plt.close()
sns.distplot(data[column])
plt.show()
1) circularity, distance_circularity,scatter_ratio,max.length_aspect_ratio,elongatedness,pr.axis_rectangularity,scaled_variance,scaled_variance_1 and hollows_ratio have bi-modal tendency.¶
2) radius_ratio and skewness_about have uniform distribution but skewness_about seems to be skewed a little towards the right hand side.¶
3) max.length_aspect ratio is very much skewed towards the right-hand side and hence might not be a good predictor¶
4) Rest of the variables have normal distributions with skewness values specified below.¶
In [20]:
# Checking for the skewness of the predictors
from scipy import stats
skews = []
for i in c_cols:
skew = stats.skew(data[i])
skews.append(skew)
for i in range(len(skews)) :
print('The skewness of ',c_cols[i],'is: ',skews[i])
------------------------------------------OUTLIER TREATMENT------------------------------------------¶
In [21]:
# Using boxplots to find out the outliers (Bivariate Analysis)
for i in c_cols:
data.boxplot(i,by='class')
plt.tight_layout()
plt.title('',y=1.08)
plt.xlabel('Class')
plt.ylabel(i)
-I have replaced only the extreme points among the outliers with a logical value (the max value of that variable for that particular class(van,car or bus))¶
Outlier treatment for 'radius_ratio'¶
In [22]:
value = data[(data['radius_ratio']<275) & (data['class']=='van')]['radius_ratio'].max()
In [23]:
value
Out[23]:
In [24]:
data['radius_ratio'][data['radius_ratio']>275]=value # Replacing the outlier with the logical value
In [25]:
value = data[(data['radius_ratio']<200) & (data['class']=='van')]['radius_ratio'].max()
value
Out[25]:
In [26]:
data['radius_ratio'][(data['radius_ratio']>200) & (data['class']=='van')]=value # Replacing the outlier with the logical value
Outlier treatment for 'pr.axis_aspect_ratio'¶
In [27]:
value = data[(data['class']=='bus')&(data['pr.axis_aspect_ratio']<80)]['pr.axis_aspect_ratio'].max()
value
Out[27]:
In [28]:
data['pr.axis_aspect_ratio'][(data['pr.axis_aspect_ratio']>=value) & (data['class']=='bus')]=value
In [29]:
value = data[(data['class']=='van')&(data['pr.axis_aspect_ratio']<80)]['pr.axis_aspect_ratio'].max()
value
Out[29]:
In [30]:
data['pr.axis_aspect_ratio'][(data['pr.axis_aspect_ratio']>=value) & (data['class']=='van')]=value
Outlier treatment for 'max.length_aspect_ratio'¶
In [31]:
value = data[(data['class']=='bus')&(data['max.length_aspect_ratio']<15)]['max.length_aspect_ratio'].max()
value
Out[31]:
In [32]:
data['max.length_aspect_ratio'][(data['max.length_aspect_ratio']>=value) & (data['class']=='bus')]=value
In [33]:
value = data[(data['class']=='van')&(data['max.length_aspect_ratio']<20)]['max.length_aspect_ratio'].max()
value
Out[33]:
In [34]:
data['max.length_aspect_ratio'][(data['max.length_aspect_ratio']>value) & (data['class']=='van')]=value
Outlier treatment for 'scaled_variance'¶
In [35]:
value = data[(data['class']=='van')&(data['scaled_variance']<=225)]['scaled_variance'].max()
value
Out[35]:
In [36]:
data['scaled_variance'][(data['scaled_variance']>value) & (data['class']=='van')]=value
In [37]:
value = data[(data['class']=='van')&(data['scaled_variance']<200)]['scaled_variance'].max()
value
Out[37]:
In [38]:
data['scaled_variance'][(data['scaled_variance']>value) & (data['class']=='van')]=value
Outlier treatment for 'scaled_radius_of_gyration.1'¶
In [39]:
value = data[(data['class']=='bus') & (data['scaled_radius_of_gyration.1']<110)]['scaled_radius_of_gyration.1'].max()
value
Out[39]:
In [40]:
data['scaled_radius_of_gyration.1'][(data['scaled_radius_of_gyration.1']>value) & (data['class']=='bus')]=value
In [41]:
value = data[(data['class']=='van') & (data['scaled_radius_of_gyration.1']<110)]['scaled_radius_of_gyration.1'].max()
value
Out[41]:
In [42]:
data['scaled_radius_of_gyration.1'][(data['scaled_radius_of_gyration.1']>value) & (data['class']=='van')]=value
In [43]:
value = data[(data['class']=='van') & (data['scaled_radius_of_gyration.1']<95)]['scaled_radius_of_gyration.1'].max()
value
Out[43]:
In [44]:
data['scaled_radius_of_gyration.1'][(data['scaled_radius_of_gyration.1']>value) & (data['class']=='van')]=value
Outlier treatment for 'skewness_about'¶
In [45]:
value = data[(data['class']=='bus') & (data['skewness_about']<15)]['skewness_about'].max()
value
Out[45]:
In [46]:
data['skewness_about'][(data['skewness_about']>value) & (data['class']=='bus')]=value
In [47]:
value1 = data[(data['class']=='van') & (data['skewness_about']<20)]['skewness_about'].max()
value1
Out[47]:
In [48]:
value = data[(data['class']=='van') & (data['skewness_about']<value1)]['skewness_about'].max()
value
Out[48]:
In [49]:
data['skewness_about'][(data['skewness_about']>value) & (data['class']=='van')]=value
Outlier treatment for 'skewness_about.1'¶
In [50]:
value1 = data[(data['class']=='van') & (data['skewness_about.1']<30)]['skewness_about.1'].max()
value1
Out[50]:
In [51]:
value = data[(data['class']=='van') & (data['skewness_about.1']<value1)]['skewness_about.1'].max()
value
Out[51]:
In [52]:
data['skewness_about.1'][(data['skewness_about.1']>value) & (data['class']=='van')]=value
Outlier treatment for 'skewness_about.2'¶
In [53]:
value = data[(data['class']=='car') & (data['skewness_about.2']<205)]['skewness_about.2'].max()
value
Out[53]:
In [54]:
data['skewness_about.2'][(data['skewness_about.2']>value) & (data['class']=='car')]=value
Outlier treatment for 'pr.axis_rectangularity'¶
In [55]:
value = data[(data['class']=='bus') & (data['pr.axis_rectangularity']<=24)]['pr.axis_rectangularity'].max()
value
Out[55]:
In [56]:
data['pr.axis_rectangularity'][(data['pr.axis_rectangularity']>value) & (data['class']=='bus')]=value
In [57]:
value = data[(data['class']=='van') & (data['pr.axis_rectangularity']<23)]['pr.axis_rectangularity'].max()
value
Out[57]:
In [58]:
data['pr.axis_rectangularity'][(data['pr.axis_rectangularity']>value) & (data['class']=='van')]=value
Plotting the boxplots after outlier treatment¶
In [59]:
for i in c_cols:
data.boxplot(i,by='class')
plt.tight_layout()
plt.title('',y=1.08)
plt.xlabel('Class')
plt.ylabel(i)
-The outliers are still present but there are no extreme points as such.¶
Feature Selection using statistical tests¶
ANOVA test (Categorical vs Continuous)¶
H0 : There is NO relation between the given variables (p > 0.05)
H1 : There is a relation between the given variables (p <= 0.05)
In [60]:
from scipy.stats import f_oneway
anova = []
for i in c_cols :
l = data.groupby('class')[i].apply(list)
res = f_oneway(*l)
anova.append(i +': '+str(res[1]))
for i in anova:
print(i)
-By looking at the p-values for each of the variables, all the variables have importance. So, we do not have to drop any.¶
Saving the dataframe as a pickle file so that the data can be loaded quickly and used in the models¶
In [61]:
data.to_pickle('object_detection_data.pickle')
In [62]:
detection_data = pd.read_pickle('object_detection_data.pickle')
detection_data.head()
Out[62]:
In [63]:
detection_data.isnull().sum()
Out[63]:
-The data has been processed and can be used in the models.¶
--------------------------------------------------------------------------------------------------------------¶
Machine Learning¶
Supervised Learning using SVM¶
In [64]:
# Separating the target variable from the predictor variables
x = detection_data.drop('class',axis=1).values
y = detection_data[['class']].values
y = y.reshape(len(y),1)
print('The shape of X is: ',x.shape)
print('The shape of y is: ',y.shape)
Converting the features into their z-scores (Scaling)¶
In [65]:
from scipy.stats import zscore
X = data.drop('class',axis=1)
X_scaled = X.apply(zscore)
X = X_scaled.values
print('The shape of X is: ',X.shape)
print('The shape of y is: ',y.shape)
X_scaled.head()
Out[65]:
3) Splitting the data into training and test set in the ratio of 70:30 respectively¶
In [66]:
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=14)
print('The shape of X_train is: ',X_train.shape)
print('The shape of y_train is: ',y_train.shape)
print('The shape of X_test is: ',X_test.shape)
print('The shape of y_test is: ',y_test.shape)
4) Train a Support vector machine using the train set and get the accuracy on the test set¶
--- Support Vector Machines ---¶
In [67]:
from sklearn import svm
model_svm = svm.SVC(C=20, kernel='rbf', gamma=0.01)
print(model_svm)
model_SVM = model_svm.fit(X_train,y_train)
y_pred = model_SVM.predict(X_test)
Confusion Matrix and Classification report¶
In [68]:
from sklearn import metrics
cm_svm=metrics.confusion_matrix(y_test, y_pred, labels=['bus', 'car','van'])
df_cm_svm = pd.DataFrame(cm_svm, index = [i for i in ["bus","car","van"]],
columns = [i for i in ["Predict bus","Predict car","Predict van"]])
plt.figure(figsize = (9,7))
sns.heatmap(df_cm_svm, annot=True,fmt='g',cmap='afmhot')
Out[68]:
In [69]:
print(metrics.classification_report(y_test,y_pred))
In [70]:
accuracy_svm = metrics.classification_report(y_test, y_pred).split()[-2]
accuracy_percentage_svm = float(accuracy_svm)*100
In [71]:
print('The Accuracy of the SVM model is :',accuracy_percentage_svm,'%')
In [72]:
score_svm = np.round((model_svm.score(X_test,y_test)*100),2)
print('The score of the SVM model on the test data is: ',score_svm,'%')
5) Perform K-fold cross validation and get the cross validation score of the model¶
--- K-fold-cross validation ---¶
In [73]:
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
cv = KFold(n_splits=10, random_state=19, shuffle=True)
k_fold_accuracy_scores = cross_val_score(model_svm,X,y,cv=cv)
k_fold_accuracy_score_svm = round((k_fold_accuracy_scores*100).mean(),2)
print('\nThe final average accuracy of the SVM model using K-fold-cross validation is: ',k_fold_accuracy_score_svm,'%')
6) and 7) Unsupervised Learning - Principal Component Analysis¶
In [74]:
from sklearn.decomposition import PCA
# Creating maximum components equal to the total number of columns to analyze all of them
pca = PCA(n_components=X.shape[1])
# fitting the data
pca_fit = pca.fit(X)
# calculating the principal components
reduced_X = pca_fit.transform(X)
# 18 columns present in X are now represented by 18 Principal components present in reduced_X
print(np.round(reduced_X[0:3],2))
In [75]:
# The Amount of variance explained by each principle componnent
var_explained= pca.explained_variance_ratio_
print(np.round(var_explained,2))
# The first component and second component explain 54% and 18% variance of data respectively
In [76]:
#Cumulative Variance explained by each component
var_explained_cumulative=np.cumsum(np.round(pca.explained_variance_ratio_, decimals=4)*100)
print(var_explained_cumulative)
What is the optimal number of Principal Components??¶
In [77]:
# By Looking at below graph we can see that >6 components are explaining maximum Variance in the dataset
plt.plot( range(1,19), var_explained_cumulative )
plt.xlabel('Number of components')
plt.ylabel('% Variance explained')
Out[77]:
The elbow occurs at 6th principal component¶
In [78]:
# Choosing 6-principal components based on above graph
pca = PCA(n_components=6)
# fitting the data
pca_fit=pca.fit(X)
# calculating the principal components
reduced_X = pca_fit.transform(X)
# 18 Columns present in X are now represented by 6-Principal components present in reduced_X
print(np.round(reduced_X[0:10],2))
In [79]:
sns.pairplot(pd.DataFrame(reduced_X))
Out[79]:
In [80]:
PCA_detection_data=pd.DataFrame(reduced_X, columns=['PC1','PC2','PC3','PC4','PC5','PC6'])
PCA_detection_data['Class']=y
PCA_detection_data.head()
Out[80]:
In [81]:
X_PCA = PCA_detection_data.drop('Class',axis=1)
y_PCA = PCA_detection_data[['Class']].values
y_PCA = y_PCA.reshape(len(y),1)
print('The shape of X_PCA is: ',X_PCA.shape)
print('The shape of y_PCA is: ',y_PCA.shape)
X_PCA.head()
Out[81]:
In [82]:
X_train_PCA,X_test_PCA,y_train_PCA,y_test_PCA = train_test_split(X_PCA,y_PCA,test_size=0.3,random_state=14)
print('The shape of X_train_PCA is: ',X_train_PCA.shape)
print('The shape of y_train_PCA is: ',y_train_PCA.shape)
print('The shape of X_test_PCA is: ',X_test_PCA.shape)
print('The shape of y_test_PCA is: ',y_test_PCA.shape)
--- Support Vector Machines ---¶
In [83]:
from sklearn import svm
model_svm_pca = svm.SVC(C=20, kernel='rbf', gamma=0.01)
print(model_svm_pca)
model_SVM_PCA = model_svm_pca.fit(X_train_PCA,y_train_PCA)
y_pred_PCA = model_SVM_PCA.predict(X_test_PCA)
Confusion Matrix and Classification report¶
In [84]:
from sklearn import metrics
cm_svm_pca=metrics.confusion_matrix(y_test_PCA, y_pred_PCA, labels=['bus', 'car','van'])
df_cm_svm_pca = pd.DataFrame(cm_svm_pca, index = [i for i in ["bus","car","van"]],
columns = [i for i in ["Predict bus","Predict car","Predict van"]])
plt.figure(figsize = (9,7))
sns.heatmap(df_cm_svm_pca, annot=True,fmt='g',cmap='afmhot')
Out[84]:
In [85]:
print(metrics.classification_report(y_test_PCA,y_pred_PCA))
accuracy_svm = metrics.classification_report(y_test_PCA, y_pred_PCA).split()[-2]
accuracy_percentage_svm = float(accuracy_svm)*100
print('The Accuracy of the SVM model using PCA is :',accuracy_percentage_svm,'%')
In [86]:
score_svm_pca = np.round((model_svm_pca.score(X_test_PCA,y_test_PCA)*100),2)
print('The score of the SVM model on the test data is: ',score_svm_pca,'%')
--- K-fold-cross validation ---¶
In [87]:
from sklearn.model_selection import cross_val_score
cv = KFold(n_splits=10, random_state=19, shuffle=True)
k_fold_accuracy_scores = cross_val_score(model_svm_pca,X_PCA,y_PCA,cv=cv)
k_fold_accuracy_score_svm_pca = round((k_fold_accuracy_scores*100).mean(),2)
print('\nThe final average accuracy of the SVM model using PCA and K-fold-cross validation is: ', k_fold_accuracy_score_svm_pca,'%')
8) Comparing the accuracy scores and cross validation scores of Support vector machines – one trained using raw data and the other using Principal Components¶
In [88]:
Accuracy_Scores = pd.DataFrame(data=[[score_svm,k_fold_accuracy_score_svm],[score_svm_pca,k_fold_accuracy_score_svm_pca]],index=['SVM-Raw Data','SVM with PCA'],columns=['Accuracy Score (%)','Cross Validation Score (%)'])
Accuracy_Scores
Out[88]: